#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
using namespace std;


struct Point
{
    int x, y;
    void operator=(Point p)
    {
        x = p.x;
        y = p.y;
    }
};
struct BoundingBox
{
    Point leftTop;
    int width;
    int height;

    BoundingBox(const Point& p1, const Point& p2)
    {
        int x1 = p1.x;
        int y1 = p1.y;
        int x2 = p2.x;
        int y2 = p2.y;

        if (x1 < x2) { leftTop.x = x1; width = x2 - x1; }
        else         { leftTop.x = x2; width = x1 - x2; }
        if (y1 > y2) { leftTop.y = y1; height = y1 - y2; }
        else         { leftTop.y = y2; height = y2 - y1; }
    }

    void operator=(BoundingBox b)
    {
        leftTop = b.leftTop;
        width = b.width;
        height = b.height;
    }

};
struct Line
{
    Point p1;
    Point p2;
};

bool operator==(Point p1, Point p2)
{
    return (p1.x == p2.x && p1.y == p2.y);
}
int max(int a, int b)
{
    return (a > b) ? a : b;
}
int min(int a, int b)
{
    return (a < b) ? a : b;
}

// make the following calulation "integer-only"
const int factor = 1000; 
const double _1_factor = 1.0 / factor;


int xmultWithSharedPoint(const Point& p1, const Point& p2, const Point& pShare);
bool onSegment(const Point& p, const Line& line);
bool checkValid(const vector<Point>& polygon);
bool checkBoundingBox(const BoundingBox& box1, const BoundingBox& box2);
bool checkIntersect(const Line& line1, const Line& line2);
int polygonArea(const vector<Point>& polygon);

#define READ_FILE

int main()
{
#ifdef READ_FILE
    ifstream readIn("1010.input");
	if (!readIn)
	{
		readIn.open("../1010.input");
	}
#else
#define readIn cin
#endif

    int n = 0;
    double tmp;
    
    readIn >> n;
    vector<Point> polygon;

    int count = 1;

    while (n > 0)
    {
        polygon.clear();

        Point p;
        for (int i = 0; i < n; i++)
        {
            readIn >> tmp;
            p.x = (int)(tmp * factor);
            readIn >> tmp;
            p.y = (int)(tmp * factor);
            polygon.push_back(p);
        }

        if (count > 1)
        {
            cout << endl;
        }

        cout << "Figure " << count << ": ";

        bool isValid = checkValid(polygon);
        if (!isValid)
        {
            cout << "Impossible" << endl;
        }
        else
        {
            int fakeArea = polygonArea(polygon);
            if (fakeArea == 0)
            {
                cout << "Impossible" << endl;
            }
            else
            {
                double realArea = _1_factor * _1_factor * (fakeArea >> 1); 
                realArea = (realArea < 0) ? -realArea : realArea;
                cout << setiosflags(ios::fixed) << setprecision(2) << realArea << endl;
            }
        }

        count++;
        readIn >> n;
    }

    return 0;
}

int xmultWithSharedPoint(const Point& p1, const Point& p2, const Point& pShare)
{
    return (p1.x - pShare.x) * (p2.y - pShare.y) - (p1.y - pShare.y) * (p2.x - pShare.x);
}
bool onSegment(const Point& p, const Line& line)
{
    if (min(line.p1.x, line.p2.x) <= p.x && p.x <= max(line.p1.x, line.p2.x) &&
        min(line.p1.y, line.p2.y) <= p.y && p.y <= max(line.p1.y, line.p2.y))
    {
        return true;
    }
    else
    {
        return false;
    }
}

//------------------------------
// check if it is a polygon
//------------------------------

// return true if valid
bool checkValid(const vector<Point>& polygon)
{
    if (polygon.size() < 3)
    {
        return false;
    }
    for (unsigned int i = 0; i < polygon.size()-1; i++)
    {
        if (polygon[i] == polygon[i+1])
        {
            return false;
        }
    }


    vector<BoundingBox> boxList;
    BoundingBox box(polygon[0], polygon[1]);

    Line line1, line2;
    for (unsigned int i = 1; i < polygon.size(); i++)
    {
        int nextI = (i + 1) % polygon.size();
        boxList.push_back(box);
        box = BoundingBox(polygon[i], polygon[nextI]);
        for (unsigned int j = 0; j < i-1; j++)
        {
            if (j == 0 && i == polygon.size()-1)
            {
                continue;
            }

            if (checkBoundingBox(boxList[j], box))
            {
                continue;
            }

            line1.p1 = polygon[i];
            line1.p2 = polygon[nextI];
            line2.p1 = polygon[j];
            line2.p2 = polygon[j+1];

            if (!checkIntersect(line1, line2))
            {
                return false;
            }
        }
    }
    return true;
}

// return true if the bounding boxes do not intersect
bool checkBoundingBox(const BoundingBox& box1, const BoundingBox& box2)
{
    if (box2.leftTop.x - box1.leftTop.x > box1.width)
        return true;

    if (box2.leftTop.y - box1.leftTop.y > box2.height)
        return true;

    if (box1.leftTop.x - box2.leftTop.x > box2.width)
        return true;

    if (box1.leftTop.y - box2.leftTop.y > box1.height)
        return true;

    return false;
}

// return true if two lines do not intersect
bool checkIntersect(const Line& line1, const Line& line2)
{
    int res1 = xmultWithSharedPoint(line2.p1, line2.p2, line1.p1);
    int res2 = xmultWithSharedPoint(line2.p1, line2.p2, line1.p2);
    int res3 = xmultWithSharedPoint(line1.p1, line1.p2, line2.p1);
    int res4 = xmultWithSharedPoint(line1.p1, line1.p2, line2.p2);

    if ( ((res1 > 0 && res2 < 0) ||
          (res1 < 0 && res2 > 0))
         &&
         ((res3 > 0 && res4 < 0) ||
          (res3 < 0 && res4 > 0))
       )
    {
        return false;
    }

    else if (res1 == 0 && onSegment(line1.p1, line2))
    {
        return false;
    }
    else if (res2 == 0 && onSegment(line1.p2, line2))
    {
        return false;
    }
    else if (res3 == 0 && onSegment(line2.p1, line1))
    {
        return false;
    }
    else if (res4 == 0 && onSegment(line2.p2, line1))
    {
        return false;
    }

    return true;
}



//-----------------------------
// calucate the area
//-----------------------------

int polygonArea(const vector<Point>& polygon)
{
    int area = 0;
    for (unsigned int i = 1; i < polygon.size()-1; i++)
    {
        area += xmultWithSharedPoint(polygon[i], polygon[i+1], polygon[0]);
    }

    return area;
}
